new Vue({
    el: '#app',
    mixins: [Save],//组件配置文件，路径/utils/components.js
    data() {
        return {
            dataForm:{
             Code_length:'',
             Code_Serial:'',
             Row_Status:'0'
            },
            childDataForm:[{
             Code_Seriallength:'',
             Code_Type:'',
             Code_Value:'',
             Row_Status:'0',
            }],//子表
            code_type:[],
            tracecode:[]
        }
    },
    mounted() {
        this.getList() 
        this.gettracecode()
    },
    methods: {
        // 获取tracecode数据
        gettracecode(){
            httpRequest({
                url: '/generalBusiness/generalQueryByTableName',
                data: {
                    Data: 'tracecode',
                    Condition: `Row_Status='0'` // 修改条件，获取所有有效的tracecode
                },
                type:'GET'
            }).then(data => {
               this.tracecode = data;
            }).catch(xhr => {
                this.$message.error("系统错误，请联系开发者!")
            })
        },
        
        // 检查是否存在符合条件的tracecode
        async checkTracecodeExist() {
            try {
                // 构建查询条件，根据您的业务需求来定义"符合条件"
                // 这里假设条件是检查是否有相同规则的tracecode存在
                const condition = `Rules_SerialNumber='${this.dataForm.Rules_SerialNumber}' AND Row_Status='0'`;
                
                const data = await httpRequest({
                    url: '/generalBusiness/generalQueryByTableName',
                    data: {
                        Data: 'tracecode',
                        Condition: condition
                    },
                    type:'GET'
                });
                
                // 如果查询到数据且长度大于0，说明存在符合条件的tracecode
                if (data && data.length > 0) {
                    return true; // 存在
                } else {
                    return false; // 不存在
                }
            } catch (error) {
                console.error("检查tracecode失败:", error);
                this.$message.error("检查数据失败!");
                return false; // 出错时默认不允许提交
            }
        },
        
        handleChange(number){
            this.value= number | undefined
            console.log(this.value)
        },
        
        handleCheck(val, item, index) {
            console.log('handleCheck 被调用:', { val, index, item });
            
            // 如果选择的是空值，直接设置，不检查重复
            if (!val || val.trim() === '') {
                item.Code_Type = val;
                return;
            }
            
            // 检查码段类型是否重复
            if (this.checkDuplicateCodeType(val, index)) {
                this.$message.error('该码段类型"' + val + '"已被选择，请选择其他类型');
                // 使用 $nextTick 确保在DOM更新后重置
                this.$nextTick(() => {
                    item.Code_Type = '';
                });
                return;
            }
            
            item.Code_Type = val;
            
            // 根据不同的码段类型进行不同处理
            if (val === '时间日期') {
                item.Code_Value = '8';
            }        
        },
        
        checkDuplicateCodeType(selectedType, currentIndex) {
            return this.childDataForm.some((item, index) => {
                // 排除当前项
                if (index === currentIndex) return false;
                
                // 严格检查其他项的类型值
                const otherType = item.Code_Type;
                
                // 检查是否为空值（空字符串、null、undefined、只有空格）
                if (!otherType || otherType.trim() === '') {
                    return false;
                }
                
                // 检查类型是否相同
                return otherType === selectedType;
            });
        },
        
        // 获取主数据          
        getList() {
            // 码段类型
            $.ajax({
                url: absolutepath() + 'admin/data/code_type.json',
                type: 'GET',
                success: (data) => {
                    this.code_type = data;
                },
            })            
        },
         
        // 处理码流水号长度变化
        CodeNumberLength(val) {
            if (val && !isNaN(val)) {
                // 确保码流水号数值不超过设置的长度
                const currentSerial = parseInt(this.dataForm.Code_Serial) || 0;
                const maxSerial = Math.pow(10, val) - 1;
                
                if (currentSerial > maxSerial) {
                    this.dataForm.Code_Serial = '0';
                    this.$message.warning('当前流水号数值超过设置的长度限制,已重置为0');
                } else {
                    // 格式化码流水号，确保长度符合要求
                    this.formatSerialNumber(val);
                }
            }
        },
        
        // 格式化码流水号
        formatSerialNumber(length) {
            const currentSerial = parseInt(this.dataForm.Code_Serial) || 0;
            this.dataForm.Code_Serial = currentSerial.toString().padStart(length, '0');
        },
    
        handel1(val) {
            this.dataForm.Code_Serial = createUniqueString(Number(val)) 
        },
         
        //码段长度校验
        handleCheckNumber(){
            const Code_length = parseInt(this.dataForm.Code_length)
            const Code_Seriallength = parseInt(this.dataForm.Code_Seriallength)
            console.log(Code_length)
            console.log(Code_Seriallength)
            let sumlength = Code_Seriallength
            this.childDataForm.forEach(item => {
               let segmentLength = 0;
               if (item.Code_Type === '时间日期') {
                    // 时间日期类型的长度就是Code_Value的值
                    segmentLength = parseInt(item.Code_Value) || 0;
                } else if (item.Code_Type === '防伪字符') {
                    // 防伪字符固定长度
                    segmentLength = parseInt(item.Code_Value) || 0; 
                } else if (item.Code_Type === '自定义字符串') {
                    // 自定义字符串的长度就是字符串的实际长度
                    segmentLength = (item.Code_Value || '').length;
                }
                
                console.log(`码段类型: ${item.Code_Type}, 长度: ${segmentLength}`);
                sumlength += segmentLength;
            });
            console.log(sumlength)

            if(Code_length !== sumlength){
                this.$message.error("码段设置不符规则")
                return false;
            }
            return true;
        },
         
        // 验证并提交
        async handleSubmit() {
            // 表单验证
            const allValid = await this.validateAllForms();
            if (!allValid) {
                this.$message({
                    message: '存在未填写的必填项！',
                    type: 'warning'
                });
                return;
            }
            
            // 自定义验证 - 码段长度校验
            if (!this.handleCheckNumber()) {
                return;
            }  
            
            // 检查是否存在符合条件的tracecode
            this.loading = true;
            try {
                const isExist = await this.checkTracecodeExist();
                
                if (isExist) {
                    this.$message.error("该规则已被调用，无法修改！");
                    this.loading = false;
                    return;
                }
                // 如果不存在符合条件的tracecode，则继续提交
                const lJSONObject_DataSet = this.generateStructure();
                const res = await httpRequest({
                    contentType: 'JSON',
                    url: '/generalBusiness/generalSaveByRequestBody',
                    data: JSON.stringify({
                        Data: lJSONObject_DataSet
                    })
                });
                
                if (res.Status == "success") {
                    this.$message.success("提交成功");
                    window.location.href = './index.html';
                } else {
                    this.$message.error("提交失败，请重试！");
                }
            } catch (error) {
                console.error(error);
                this.$message.error("系统错误，请联系开发者!");
            } finally {
                this.loading = false;
            }
        }
    }
})